<?xml version="1.0" encoding="UTF-8"?>
<html>
    <head>
        <link type="text/css" rel="stylesheet" href="./css/template.css" />
        <link type="text/css" rel="stylesheet" href="./css/SyntaxHighlighter.css" />
        <meta http-equiv="Content-Type" content="text/html; charset=UTF-8" />
        <title>Comment utiliser Hibernate</title>
        <script language="javascript" src="./js/shInit.js" />
        <script language="javascript" src="./js/shCore.js" />
        <script language="javascript" src="./js/shBrushCpp.js" />
        <script language="javascript" src="./js/shBrushCSharp.js" />
        <script language="javascript" src="./js/shBrushCss.js" />
        <script language="javascript" src="./js/shBrushDelphi.js" />
        <script language="javascript" src="./js/shBrushJava.js" />
        <script language="javascript" src="./js/shBrushJScript.js" />
        <script language="javascript" src="./js/shBrushPhp.js" />
        <script language="javascript" src="./js/shBrushPython.js" />
        <script language="javascript" src="./js/shBrushRuby.js" />
        <script language="javascript" src="./js/shBrushSql.js" />
        <script language="javascript" src="./js/shBrushVb.js" />
        <script language="javascript" src="./js/shBrushXml.js" />
    </head>
    <body>
        <div class="chapter">
            <h2>1. Présentation</h2>
            <p>
                Travailler dans les deux univers que sont l'orienté objet et la base de données relationnelle peut être lourd et consommateur en temps. Hibernate se propose de joindre ces deux univers, à travers le
                <b>mapping objet/relationnel</b>
                . Le terme mapping objet/relationnel (ORM) décrit la technique consistant à faire le lien entre la représentation objet des données et sa représentation relationnelle, basé sur un schéma SQL.
            </p>
            <p>
                Hibernate s'occupe du
                <b>transfert des classes Java dans les tables de la base de données</b>
                (et des types de données Java dans les types de données SQL). Il permet également de
                <b>requêter</b>
                les données et propose des moyens de les récupérer.
            </p>
            <p>
                On peut voir Hibernate comme
                <b>une fine surcouche de JDBC qui lui ajouterait un dimension objet.</b>
            </p>
            <p />
            <center>
                <img src="./images/hibernate_html_3a3715bb.gif" alt="hibernate_html_3a3715bb.gif" />
                <br />
                Schéma simplifié du fonctionnement d'Hibernate.
            </center>
            <p>
                Nous allons voir, dans un premier temps, l'architecture d' Hibernate, à travers ses fichiers de configuration, et son framework.
                <br />
                Dans une deuxième partie, nous mettrons en pratique ce que nous avons appris à travers eclipse et le plugin " hibernate synchroniser ". Nous génèrerons les objets et la structure de la base de données automatiquement, grâce au fichier de mapping.
            </p>
            <p>Vous pouvez passer directement à la deuxième partie, si vous souhaitez voir tout de suite comment fonctionne Hibernate par la pratique, Eclipse faisant en sorte qu'avec un minimum de connaissances on puisse arriver à un résultat intéressant.</p>
            <p>Pour suivre cet article, il est nécessaire d'avoir des notions de JDBC (nous allons utiliser des PreparedStatement), en XML, et plus généralement, de bonnes bases en Java.</p>
        </div>
        <div class="chapter">
            <h2>2. Installation d'Hibernate</h2>
            <ol>
                <li>
                    Téléchargez Hibernate sur son site web, décompressez le fichier sur votre disque. Nous utiliserons ici la
                    <b>version 2.1.8</b>
                    d'Hibernate.
                </li>
            </ol>
            <p>
                Hibernate est une librairie. Elle doit donc se situer dans votre variable d'environnement classpath, ainsi que son répertoire "lib".
                <br />
                Les derniers exemples utiliseront Eclipse (
                <a href="http://download.eclipse.org" target="_blank">http://download.eclipse.org</a>
                ).
            </p>
            <ol start="2">
                <li>Le plugin "Hibernate Synchroniser" sera également utilisé. Nous verrons au moment venu la façon de l'installer.</li>
                <li>Une base de données est nécessaire. Nous utiliserons ici postgresql.</li>
                <li>
                    Nous aurons également besoin du driver JDBC de notre base de données. Voici quelques liens :
                    <ul>
                        <li>
                            pour mysql :
                            <a href="http://www.mysql.com/products/connector/j/" target="_blank">http://www.mysql.com/products/connector/j/</a>
                        </li>
                        <li>
                            pour postgresql :
                            <a href="http://jdbc.postgresql.org/" target="_blank">http://jdbc.postgresql.org/</a>
                        </li>
                        <li>
                            pour oracle :
                            <a href="http://www.oracle.com/technology/software/tech/java/sqlj_jdbc/index.html" target="_blank">http://www.oracle.com/technology/software/tech/java/sqlj_jdbc/index.html</a>
                        </li>
                    </ul>
                </li>
            </ol>
        </div>
        <div class="chapter">
            <h2>3. Lier Hibernate avec une base de données</h2>
            <p>Nous verrons ici deux façons de configurer l'accès à la base de données.</p>
            <p>Ces fichiers définissent les propriétés de la connexion. Voici les propriétés revenant régulièrement :</p>
            <table border="1">
                <tbody>
                    <tr>
                        <td bgcolor="#e6e6e6">
                            <b>hibernate.connection.driver_class</b>
                        </td>
                        <td bgcolor="#e6e6e6">Classe du driver jdbc</td>
                    </tr>
                </tbody>
                <tbody>
                    <tr valign="top">
                        <td bgcolor="#e6e6e6">
                            <b>hibernate.connection.url</b>
                        </td>
                        <td bgcolor="#e6e6e6">URL jdbc</td>
                    </tr>
                    <tr valign="top">
                        <td bgcolor="#e6e6e6">
                            <b>
                                hibernate.connection.username
                                <br />
                            </b>
                        </td>
                        <td bgcolor="#e6e6e6">Utilisateur de la base de données</td>
                    </tr>
                    <tr valign="top">
                        <td bgcolor="#e6e6e6">
                            <b>hibernate.connection.password</b>
                        </td>
                        <td bgcolor="#e6e6e6">Mot de passe de la base de données</td>
                    </tr>
                    <tr valign="top">
                        <td bgcolor="#e6e6e6">
                            <b>hibernate.dialect</b>
                        </td>
                        <td bgcolor="#e6e6e6">
                            Le nom de la classe du Dialect Hibernate - active l'utilisation de certaines fonctionnalités spécifiques à la plateforme
                            <i>(optionnel).</i>
                            <br />
                            <i>
                                <u>Quelques exemples parmis les SGBDr les plus utilisés :</u>
                                <br />
                                net.sf.hibernate.dialect.PostgreSQLDialect (postgresql)
                                <br />
                                s
								net.sf.hibernate.dialect.MySQLDialect (mysql)
                                <br />
                                net.sf.hibernate.dialect.OracleDialect (oracle)
                                <br />
                                net.sf.hibernate.dialect.SQLServerDialect (sqlserver)
                                <br />
                                ...
                            </i>
                        </td>
                    </tr>
                    <tr valign="top">
                        <td bgcolor="#e6e6e6">
                            <b>hibernate.default_schema</b>
                        </td>
                        <td bgcolor="#e6e6e6">
                            Positionne dans le SQL généré un schéma/tablespace par défaut pour les noms de table ne l'ayant pas surchargé
                            <i>(optionnel).</i>
                        </td>
                    </tr>
                    <tr valign="top">
                        <td bgcolor="#e6e6e6">
                            <b>hibernate.show_sql</b>
                        </td>
                        <td bgcolor="#e6e6e6">
                            Mis sur "
                            <i> true </i>
                            ", ce paramètre permet d'afficher dans la console les requêtes sql générées par l'architecture Hibernate.
                            <i>(optionnel)</i>
                        </td>
                    </tr>
                    <tr valign="top">
                        <td bgcolor="#e6e6e6">
                            <b>hibernate.connection.datasource</b>
                        </td>
                        <td bgcolor="#e6e6e6">Nom JNDI de la source de données. Utilisé notamment quand le serveur d'application héberge un pool de connexion JDBC.</td>
                    </tr>
                    <tr valign="top">
                        <td bgcolor="#e6e6e6">
                            <b>hibernate.query.substitutions</b>
                        </td>
                        <td bgcolor="#e6e6e6">
                            Vous pouvez définir de nouveaux tokens dans les requêtes Hibernate en utilisant la propriété.
                            <br />
                            <u>Exemple :</u>
                            <br />
                            <i>hibernate.query.substitutions vrai=1, faux=0</i>
                            <br />
                            remplacerait les tokens vrai et faux par des entiers dans le SQL généré.
                            <br />
                            <i>hibernate.query.substitutions toLowercase=LOWER</i>
                            <br />
                            permettrait de renommer la fonction SQL LOWER en toLowercase.
                        </td>
                    </tr>
                </tbody>
            </table>
            <div class="subChapter">
                <h3>3.1. Le fichier hibernate.properties</h3>
                <p>
                    Il s'agit d'un fichier texte placé dans le classpath de votre projet (WEB-INF/classes pour un projet web). Il est au format "clé=valeur".
                    <br />
                    Vous trouverez un exemple de le répertoire "etc" d'Hibernate.
                </p>
                <p>Voici un exemple, adapté à une base de données PostGreSql :</p>
                <textarea name="code" class="java">hibernate.dialect net.sf.hibernate.dialect.PostgreSQLDialect
					hibernate.connection.driver_class org.postgresql.Driver
					hibernate.connection.url jdbc:postgresql://192.168.0.1/quickstart
					hibernate.connection.username jibe
					hibernate.connection.password tatiana
					hibernate.query.substitutions yes 'Y', no 'N'</textarea>
            </div>
            <div class="subChapter">
                <h3>3.2. Le fichier hibernate.cfg.xml</h3>
                <p>
                    Ce fichier a exactement la même utilité que
                    <b>hibernate.properties</b>
                    .
                    <br />
                    Sa syntaxe est bien sûr en xml. Ses valeurs surchargent celles d'"hibernate.properties" si les deux fichiers sont présents.
                </p>
                <textarea name="code" class="xml">
                    &lt;?xml version="1.0" encoding="utf-8"?&gt;
                    <hibernate-configuration>
                        <session-factory>
                            <!--
							local connection properties -->
                            <property name="hibernate.connection.url">jdbc:postgresql://jibe77.org/quickstart</property>
                            <property name="hibernate.connection.driver_class">org.postgresql.Driver</property>
                            <property name="hibernate.connection.username">jibe</property>
                            <property name="hibernate.connection.password">tatiana</property>
                            <!-- property name="hibernate.connection.pool_size"></property -->
                            <!-- dialect for PostgreSQL -->
                            <property name="dialect">net.sf.hibernate.dialect.PostgreSQLDialect</property>
                            <property name="hibernate.show_sql">false</property>
                            <property name="hibernate.transaction.factory_class">net.sf.hibernate.transaction.JDBCTransactionFactory</property>
                            <mapping resource="com/supinfo/labosun/Contact.hbm" />
                        </session-factory>
                    </hibernate-configuration>
                </textarea>
                <p>
                    Les balises "property" permettent donc de renseigner une paire "clé-valeur".
                    <br />
                    Dans la deuxième partie du fichier, la balise "mapping" permet de renseigner les fichiers de mapping entre la base de données et les objets persistants. Nous les verront plus tard.
                </p>
            </div>
        </div>
        <div class="chapter">
            <h2>4. Ecrire un fichier de mapping</h2>
            <p>
                Le fichier de mapping permet de lier la base de données avec les objets persistants.
                <br />
                Il est écrit en xml. Voici ses éléments :
            </p>
            <textarea name="code" class="xml">
                &lt;?xml version="1.0"?&gt;
                <hibernate-mapping>
                    <class name="net.sf.hibernate.examples.quickstart.Cat" table="CAT">
                        <id name="id" type="string" unsaved-value="null">
                            <column name="id_cat" sql-type="char(32)" not-null="      class=" sourcekeyword="sourceKeyword">
                                true"/&gt;
                                <generator />
                            </column>
                        </id>
                        <property name="name">
                            <column name="name_cat" length="16" not-null="true" />
                        </property>
                        <property name="birthdate" type="date" />
                        <column name="birthdate_cat&quot;" />
                    </class>
                </hibernate-mapping>
            </textarea>
            <p>On peut voir que les éléments de l'objet "Cat" que nous avons créé juste avant sont liées aux colonnes de la base de données.
				Nous allons expliquer le rôle de chacune des balises que nous venons de rencontrer.</p>
            <div class="subChapter">
                <h3>4.1. class</h3>
                <p>Vous pouvez déclarer une classe persistante en utilisant l'élément class :</p>
                <ul>
                    <li>"name" déclare la classe persistante ;</li>
                    <li>"table" déclare la table à mapper.</li>
                </ul>
            </div>
            <div class="subChapter">
                <h3>4.2. id</h3>
                <p>
                    Les classes mappées doivent déclarer la colonne clé primaire de la table.
                    <br />
                    L'élément
                    <id>
                        définit le mapping entre cette propriété et cette colonne clé primaire.
                        <br />
                        <ul>
                            <li>
                                "name" définit la variable servant d'identifiant dans l'objet persistant
                                <i>(optionnel)</i>
                                ,
                            </li>
                            <li>
                                "type" définit le type de la variable utilisée
                                <i>(optionnel)</i>
                                .
                            </li>
                        </ul>
                        Type peut être :
                        <ol>
                            <li>Le nom d'un type Hibernate basique (ex. integer, string, character, date, timestamp, float, binary, serializable, object, blob).</li>
                            <li>Le nom d'une classe Java avec un type basique par défaut (eg. int, float, char, java.lang.String, java.util.Date, java.lang.Integer, java.sql.Clob).</li>
                            <li>Le nom d'une classe Java serialisable.</li>
                            <li>Le nom d'une classe Java implémentant un type personnalisé.</li>
                        </ol>
                    </id>
                </p>
            </div>
            <div class="subChapter">
                <h3>4.3. column</h3>
                <p>
                    L'élément fils optionnel
                    <b>"column"</b>
                    définit le champs utilisé dans la base de données. Il peut être associé aux balises
                    <b>id</b>
                    et
                    <b>property</b>
                    .
                    <br />
                    L'attribut " sql-type " est utilisé pour définir le type du champ dans la base de données
                    <i>(optionnel, hibernate fait la conversion automatiquement)</i>
                    .
                </p>
            </div>
            <div class="subChapter">
                <h3>4.4. generator</h3>
                <p>
                    L'élément fils de l'id définit la classe Java utilisée pour générer l'identifiant unique des instances d'une classe persistante.
                    <br />
                    <b>"class"</b>
                    permet de définir la façon de créer cet identifiant. Voici les plus généralement utilisées :
                </p>
                <ul>
                    <li>
                        <b>increment</b>
                        <br />
                        génère des identifiants du type long, short ou int qui sont uniques seuleument lorsqu'aucun autre process n'insère de données dans la même table.
                    </li>
                    <li>
                        <b>sequence</b>
                        utilise une sequence dans DB2, PostgreSQL, Oracle, SAP DB, McKoi ou un générateur dans Interbase.
                        <br />
                        L'identifiant retourné est de type long, short ou int.
                    </li>
                    <li>
                        <b>uuid.hex</b>
                        utilise l'algorithme à 128-bit UUID pour générer les identifiants de type string, uniques sur un réseau donné (l'adresse IP est utilisée).
                        <br />
                        L'UUID est encodée comme une chaîne de 32 chiffres hexadécimaux.
                    </li>
                </ul>
            </div>
            <div class="subChapter">
                <h3>4.5. property</h3>
                <p>
                    L'élément
                    <b>property</b>
                    déclare une propriété persistante de la classe, respectant la convention JavaBean.
                </p>
                <p />
                <ul>
                    <li>
                        L'attribut optionnel
                        <b>name</b>
                        définit la variable servant d'identifiant dans l'objet persistant.
                    </li>
                    <li>
                        L'attribut optionnel
                        <b>type</b>
                        définit le type de la variable utilisée.
                    </li>
                </ul>
                Il existe de nombreuses autres balises, notamment pour établir les relations entre les tables. Nous en verrons certaines plus tard, lors de l'utilisation du plugin Eclipse.
            </div>
        </div>
        <div class="chapter">
            <h2>5. Ecrire une classe persistante</h2>
            <p>
                Les objets persistants sont tout simplement des objets respectant les caractéristiques des
                <b>JavaBeans</b>
                : l'utilisation des getters/setters.
            </p>
            <p>
                Voici un exemple :
                <br />
                <textarea name="code" class="java">package eg;
					import java.util.Set;
					import java.util.Date;
					public class Cat {
					private Long id;
					private String name;
					private Date birthdate;
					private void getId(Long id) {
					this.id=id;
					}
					public Long getId() {
					return id;
					}
					void setName(String name) {
					this.name = name;
					}
					public String getName() {
					return name;
					}
					void setDate(Date date) {
					birthdate = date;
					}
					public Date getBirthdate() {
					return birthdate;
					}
					public boolean equals(Object other) {
					if (this == other)
					return true;
					if (!(other instanceof Cat))
					return false;
					final Cat cat = (Cat) other;
					if (!getName().equals(cat.getName()))
					return false;
					if (!getBirthday().equals(cat.getBirthday()))
					return false;
					return true;
					}
					public int hashCode() {
					int result;
					result = getName().hashCode();
					result = 29 * result + getBirthday().hashCode();
					}
					}</textarea>
            </p>
            <p>On remarquera que :</p>
            <ul>
                <li>
                    la
                    <b>visibilité</b>
                    des méthodes est indifférente, donc elles peuvent ètre private, default, public, ... ;
                </li>
                <li>
                    il faut laisser un
                    <b>constructeur par défaut</b>
                    (sans nécessairement être public) afin qu'Hibernate puisse l'instancier ;
                </li>
                <li>implémenter l'identifiant utilisé dans la base de données est optionnel mais conseillé pour permettre des fonctionnalités du cycle de vie (que nous verrons plus tard). Il est également conseillé d'utiliser un type non primitif.</li>
                <li>Certaines fonctionnalités internes d'Hibernate nécessitent que la classe ne soit pas finale.</li>
                <li>
                    On doit
                    <b>surcharger</b>
                    les méthodes hashCode() et equals(). Ce n'est pas toujours utile, mais c'est une bonne habitude à prendre.
                </li>
            </ul>
            <p>Nous avons vu les bases permettant d'écrire un objet persistant, nous n'allons pas approfondir ce sujet pour l'instant, en attendant de savoir comment on le manipule.</p>
        </div>
        <div class="chapter">
            <h2>6. Manipuler des objets persistants</h2>
            <p>L'architecture Hibernate possède différentes classes :</p>
            <div class="subChapter">
                <h3>6.1. Configuration (net.sf.hibernate.Configuration)</h3>
                <p>Représente un ensemble de mappings des classes Java d'une application vers la base de données SQL.</p>
                <textarea name="code" class="java">Configuration cfg =  Configuration();</textarea>
                <p>Si vous avez écrit un fichier de configuration de type "hibernate.properties" , il faudra ajouter les fichiers de mapping (il n'est pas possible de les ajouter à partir de ce fichier) :</p>
                <textarea name="code" class="java">cfg.addFile("Cat.cfg.xml");</textarea>
                <p>Si vous avez utilisé la configuration de type "hibernate.cfg.xml", il faudra ajouter le fichier :</p>
                <textarea name="code" class="java">File configFile =  File("hibernate.cfg.xml");
					cfg.configure(configFile);</textarea>
                <p>On voit de cette façon que l'on peut nommer ce dernier fichier de configuration comme on le souhaite.</p>
            </div>
            <div class="subChapter">
                <h3>6.2. SessionFactory (net.sf.hibernate.SessionFactory)</h3>
                <p>
                    Nous sommes maintenant prêts à utiliser la
                    <b>Session</b>
                    Hibernate. C'est l'interface du
                    <b>gestionnaire de persistance</b>
                    , on l'utilise pour sauver et récupérer les objets respectivement dans et à partir de la base de données. Mais d'abord, nous devons récupérer une
                    <b>Session</b>
                    (l'unité de travail Hibernate) à partir de la
                    <b>SessionFactory</b>
                    :
                </p>
                <textarea name="code" class="java">SessionFactory sessionFactory = cfg.buildSessionFactory();</textarea>
                <p>
                    En général, une
                    <b>SessionFactory</b>
                    n'est construite qu'une seule fois, c'est-à-dire au démarrage (avec une servlet de type
                    <b>load-on-startup</b>
                    ). Cela veut donc dire que l'on ne doit pas la garder dans une variable d'instance des servlets, mais plutôt ailleurs. Il faut un support de type
                    <b>Singleton</b>
                    pour pouvoir y accéder facilement. L'approche montrée ci-dessous résout les deux problèmes : celui de configuration et celui de la facilité d'accès à
                    <b>SessionFactory</b>
                    .
                </p>
                <p>Nous implémentons HibernateUtil, une classe utilitaire :</p>
                <textarea name="code" class="java">net.sf.hibernate.*;
					net.sf.hibernate.cfg.*;
					HibernateUtil {
					SessionFactory sessionFactory;
					{
					{
					// Crée la SessionFactory
					sessionFactory =  Configuration().configure().buildSessionFactory();
					}  (HibernateException ex) {
					RuntimeException("Probl�me de configuration : " + ex.getMessage(), ex);
					}
					}
					ThreadLocal();
					HibernateException {
					Session s = (Session) session.get();
					// Ouvre une nouvelle Session, si ce Thread n'en a aucune
					) {
					s = sessionFactory.openSession();
					session.set(s);
					}
					s;
					}
					HibernateException {
					Session s = (Session) session.get();
					session.set();
					)
					s.close();
					}
					}</textarea>
                <p>
                    L'utilisation de
                    <b>ThreadLocale</b>
                    permet de rattacher
                    <b>chaque thread</b>
                    à un objet
                    <b>Session</b>
                    .
                </p>
                <p>
                    Les
                    <b>Sessions</b>
                    sont ouvertes par la
                    <b>SessionFactory</b>
                    et sont fermées quand le travail est terminé :
                </p>
                <textarea name="code" class="java">Session session = HibernateUtil.currentSession();
					Transaction tx= session.beginTransaction();
					Cat princess = new Cat();
					princess.setName("Princess");
					session.save(princess);
					tx.commit();
					HibernateUtil.closeSession();</textarea>
            </div>
            <div class="subChapter">
                <h3>6.3. L'accès aux méta-données</h3>
                <p>
                    Hibernate expose les métadonnées au travers des interfaces
                    <b>ClassMetadata</b>
                    et
                    <b>CollectionMetadata</b>
                    et la hiérarchie de
                    <b>Type</b>
                    . Les instances des interfaces de métadonnées peuvent être obtenues depuis la
                    <b>SessionFactory</b>
                    .
                </p>
                <textarea name="code" class="java">
                    Cat fritz =  Cat();
					ClassMetadata catMeta = sessionfactory.getClassMetadata(Cat);
					Long id = (Long) catMeta.getIdentifier(fritz);
					Object[] propertyValues = catMeta.getPropertyValues(fritz);
					String[] propertyNames = catMeta.getPropertyNames();
					Type[] propertyTypes = catMeta.getPropertyTypes();
					// retourne une Map de toutes les propriétés qui ne sont pas des collections
					ou des associations
					Map namedValues =  HashMap();
					i=0; i
                    <propertynames.length i="i" propertytypes="propertyTypes" isentitytype="isEntityType" iscollectiontype="isCollectionType" namedvalues.put="namedValues.put" propertynames="propertyNames" propertyvalues="propertyValues" />
                </textarea>
            </div>
            <div class="subChapter">
                <h3>6.4. Transaction (net.sf.hibernate.Transaction)</h3>
                <p>
                    Dans une
                    <b>Session</b>
                    , chaque opération sur la base de données se fait dans une transaction qui isole les opérations de la base de données (c'est également le cas pour les lectures seules). Nous utilisons l'API Transaction pour s'abstraire de la stratégie transactionnelle utilisée (dans notre cas, les transactions JDBC).
                </p>
                <p>
                    On obtient un objet Transaction en appelant la méthode de l'objet session nommée "
                    <b>beginTransaction()</b>
                    ".
                </p>
                <p>
                    On pourra manipuler la transaction avec les méthodes "
                    <b>commit()</b>
                    ", pour valider la transaction.
                </p>
                <textarea name="code" class="java">Session session = HibernateUtil.currentSession();
					Cat princess =  Cat();
					princess.setName("Princess");
					session.save(princess);
					HibernateUtil.closeSession();</textarea>
                <p>
                    Si vous décidez de ne pas valider vos modifications :
                    <br />
                    <b>tx.rollback();</b>
                </p>
            </div>
            <div class="subChapter">
                <h3>6.5. Session (net.sf.hibernate.Session)</h3>
                <p>C'est un objet à durée de vie courte, qui représente une conversation entre l'application et l'entrepôt de persistance. Il encapsule une connexion JDBC.</p>
                <textarea name="code" class="java">Session session = HibernateUtil.currentSession();
					Transaction tx= session.beginTransaction();
					Cat princess =  Cat();
					princess.setName("Princess");
					tx.commit();
					HibernateUtil.closeSession();</textarea>
                <p>
                    <b>save()</b>
                    avec un seul argument, génère et assigne un identifiant unique.
                </p>
                <p>
                    Il est possible de recharger un objet et toutes ses collections à n'importe quel moment en utilisant la méthode
                    <b>refresh()</b>
                    .
                </p>
                <p>
                    Vous devez invoquer
                    <b>Session.flush()</b>
                    pour vous assurer que les changements sont synchronisés avec la base de données. Cependant, si vous utilisez une
                    <b>Transaction</b>
                    , l'appel de la méthode
                    <b>commit()</b>
                    le fera automatiquement.
                </p>
                <p>
                    La méthode
                    <b>load()</b>
                    de
                    <b>Session</b>
                    vous permet de récupérer une instance persistante si vous connaissez son identifiant.
                </p>
                <textarea name="code" class="java">Cat cat = (Cat) sess.get(Cat., id);
					if (cat==) {
					cat =  Cat();
					sess.save(cat, id);
					}
					return cat;</textarea>
                <p>
                    Si vous ne connaissez pas le(s) identifiant(s) de l'objet (ou des objets) que vous recherchez, utlisez la méthode
                    <b>iterate()</b>
                    offerte par la
                    <b>Session</b>
                    , retournant un objet java.util.Iterator.
                </p>
                <textarea name="code" class="java">// itération sur les ids
					Iterator iter = sess.iterate("select mate from Cat as cat join cat.mate as mate " + "where cat.name = ?",
					name, Hibernate.STRING);
					( iter.hasNext() ) {
					Qux qux = (Qux) iter.next(); // récupération de l'objet
					...
					}
					}</textarea>
                <p>
                    Le second argument de
                    <i>iterate()</i>
                    est un objet ou un tableau d'objets.
                </p>
                <p>
                    Le troisième argument est un
                    <b>type Hibernate</b>
                    ou un tableau de types Hibernate.
                </p>
                <p>
                    Ces types passés en argument sont utilisés pour lier les objets passés en argument au ? de la requête (ce qui correspond aux paramètres d'un
                    <b>PreparedStatement</b>
                    JDBC).
                </p>
                <p>Si vous avez besoin de définir des limites sur le résultat d'une requête (nombre maximum d'enregistrements et/ou l'indice du premier résultat que vous souhaitez récupérer), utilisez une instance de net.sf.hibernate.Query :</p>
                <textarea name="code" class="java">//paramètre nommé (préféré)
					Query q = sess.createQuery("from DomesticCat cat where cat.name = ?");
					q.setString("name", "Fritz", Hibernate.STRING);
					q.setFirstResult(20);
					q.setMaxResults(10);
					Iterator cats = q.iterate();</textarea>
                <p>
                    Ces deux derniers exemple ont introduit la notion de
                    <b>HSQL</b>
                    . Il s'agit du langage d'interrogation utilisé par Hibernate. Il est très proche de SQL. Nous en reparlerons d'ici peu.
                </p>
            </div>
            <div class="subChapter">
                <h3>6.6. Mettre à jour un objet</h3>
                <p>
                    La méthode "
                    <b>saveOrUpdate()</b>
                    " de l'objet session vous permettra d'ajouter ou modifier les données automatiquement, en fonction du contexte dans lequel il s'applique.
                </p>
                <textarea name="code" class="java">// dans la première session
					Cat cat = (Cat) firstSession.load(Cat., catID);
					// dans une couche supérieure de l'application
					Cat mate =  Cat();
					cat.setName(" cesar ");
					// plus tard, dans une nouvelle session
					secondSession.saveOrUpdate(cat); // mise à jour de l'état existant (cat a un
					id non null)
					secondSession.saveOrUpdate(mate); // sauvegarde d'une nouvelle instance (mate a un id null)</textarea>
                <p>Il est nécessaire de l'utiliser quand l'objet est sauvegardé dans un objet session différent de celui qui l'a créé (très souvent le cas lorsque l'objet passe par une interface utilisateur).</p>
                <p>
                    Si l'objet persistant reste dans la juridiction de l'objet session qui l'a créé, un simple "
                    <b>flush()</b>
                    " ou un "
                    <b>commit()</b>
                    " sur la transaction est suffisant.
                </p>
            </div>
            <div class="subChapter">
                <h3>6.7. Supprimer l'objet de la source de données</h3>
                <p>
                    Session.delete() supprimera l'état d'un objet de la base de données. Evidemment, votre application peut toujours contenir une référence à cet objet.
                    <br />
                    La meilleure façon de l'apréhender est donc de se dire que
                    <b>delete()</b>
                    transforme une instance persistante en instance transiante (non-persistante).
                </p>
                <textarea name="code" class="java">session.delete(cat);</textarea>
            </div>
            <div class="subChapter">
                <h3>6.8. Les exceptions</h3>
                <p>
                    Si un problème intervient lors de la communication avec la source de données (
                    <b>SQLException</b>
                    inclus), il faut appeler un
                    <b>RollBack()</b>
                    de la session, fermer la session et ne plus l'utiliser.
                </p>
                <textarea name="code" class="java">Session sess = HibernateUtil.currentSession();
					Transaction tx = ;
					{
					tx = sess.beginTransaction();
					// faire qqch
					...
					tx.commit();
					}
					(Exception e) {
					if (tx!=null) tx.rollback();
					e;
					}
					{
					sess.closeSession();
					}</textarea>
            </div>
        </div>
        <div class="chapter">
            <h2>7. HSQL : les requêtes SQL d'Hibernate</h2>
            <p>Hibernate fournit un langage d'interrogation extrêmement puissant qui ressemble (et c'est voulu) au SQL. HSQL est totalement orienté objet, comprenant des notions d'héritage, de polymorphisme et d'association.</p>
            <p>Ce langage est insensible à la casse, sauf au niveau des noms des objets Java.</p>
            <p>
                Les éléments que l'on spécifie font partie de l'objet persistant, et non de la base de donnée.
                <b>A aucun moment, on ne spécifie d'élément faisant partie de la base de données</b>
                (c'est le travail des fichiers de mapping).
            </p>
            <p>
                <b>Pour bien comprendre Hibernate, il faut raisonner en Objet et pas en terme de SGBD relationnel.</b>
            </p>
            <div class="subChapter">
                <h3>7.1. La clause from</h3>
                <p>La requête Hibernate la plus simple est de la forme :</p>
                <textarea name="code" class="java">from eg.Cat</textarea>
                <p>qui retourne simplement toutes les instances de la classe eg.Cat.</p>
                <p>
                    La plupart du temps, vous devrez assigner un
                    <i>alias</i>
                    puisque vous voudrez faire référence à Cat dans d'autres parties de la requête.
                </p>
                <textarea name="code" class="java">from eg.Cat as cat</textarea>
            </div>
            <div class="subChapter">
                <h3>7.2. La clause where</h3>
                <p>
                    La clause
                    <b>where</b>
                    vous permet de réduire la liste des instances retournées.
                </p>
                <textarea name="code" class="java">from eg.Cat as cat where cat.name='Fritz'</textarea>
                <p>
                    retourne les instances de Cat dont
                    <i>name</i>
                    est égal à 'Fritz'.
                </p>
                <textarea name="code" class="java">select foo
					from eg.Foo foo, eg.Bar bar
					where foo.startDate = bar.date</textarea>
                <p>
                    retournera les instances de Foo pour lesquelles il existe une instance de bar avec la propriété
                    <i>date</i>
                    égale à la propriété
                    <i>startDate</i>
                    de Foo. Les expressions utilisant la navigation rendent la clause
                    <b>where</b>
                    extrêmement puissante. Soit :
                </p>
                <textarea name="code" class="java">from eg.Cat cat where cat.mate.name is not null</textarea>
            </div>
            <div class="subChapter">
                <h3>7.3. La clause select</h3>
                <p>
                    La clause
                    <b>select</b>
                    sélectionne les objets et propriétés qui doivent être retournés dans le résultat de la requête.
                    <br />
                    Soit :
                </p>
                <textarea name="code" class="java">select mate
					from eg.Cat as cat</textarea>
            </div>
        </div>
        <div class="chapter">
            <h2>8. Le plugin Eclipse</h2>
            <p>
                Nous allons à présent utiliser Eclipse et son plugin Hibernate : "
                <b>hibernate-synchronizer</b>
                ".
				Cela nous permettra de nous intéresser d'avantage à l'écriture du fichier de mapping. Il s'agit de loin la partie intéressante de l'architecture, car on pourra automatiser le processus de création de base de données, ainsi que des objets persistants.
            </p>
        </div>
        <div class="chapter">
            <h2>9. Installation du plugin</h2>
            <p>Le plugin s'installle en utilisant "plugin-manager".</p>
            <ol>
                <li>
                    Ouvrer le menu :
                    <b>Help -&gt; Software Updates -&gt;  Update Manager ou Find and Install</b>
                    (différent en fonction des versions)
                    <img src="./images/hibernate_html_37eb3c97.gif" alt="hibernate_html_37eb3c97.gif" />
                </li>
                <li>Sélectionnez "Search for new features to install ".</li>
                <li>
                    Voici les liens à entrer (utilisez le bouton "
                    <b>New Remote Site...</b>
                    ")
                    <ul>
                        <li>Eclipse 2.1: http://www.binamics.com/hibernatesync/eclipse2.1</li>
                        <li>Eclipse 3: http://www.binamics.com/hibernatesync</li>
                    </ul>
                    <img src="./images/hibernate_html_7d9025fd.gif" alt="hibernate_html_7d9025fd.gif" />
                </li>
                <li>Laissez vous guider par les fenêtres, en acceptant la licence (hibernate est sous licence LGPL et hibernate-synchronizer sous GPL, donc ils sont gratuits et open-source).</li>
                <li>Redémarrez Eclipse quand il vous le demandera, à la fin de l'installation.</li>
            </ol>
        </div>
        <div class="chapter">
            <h2>10. Créer un projet</h2>
            <p>Nous allons créer le projet qui nous permettra de travailler avec le plugin hibernate :</p>
            <ol>
                <li>File -&gt; New -&gt; Project ... -&gt; Java Project ...</li>
                <img src="./images/hibernate_html_4d3057a0.gif" alt="hibernate_html_4d3057a0.gif" />
                <li>Nommez le projet "Hibernate Test", à défaut de trouver plus original :-)</li>
                <img src="./images/hibernate_html_md6f3d20.gif" alt="hibernate_html_md6f3d20.gif" />
                <li>Cliquez sur "Next".</li>
                <li>
                    Sélectionnez l'onglet "
                    <b>librairies</b>
                    ", et cliquez sur le bouton "
                    <b>Add external jars ....</b>
                    ". Il faudra sélectionner "
                    <b>hibernate2.jar</b>
                    " situé à la racine du dossier d'Hibernate, l'ensemble des librairies du répertoire "
                    <b>lib</b>
                    " situé dans le répertoire d'Hibernate, et enfin le driver de votre base de données.
                </li>
            </ol>
        </div>
        <div class="chapter">
            <h2>11. Créer le fichier de configuration</h2>
            <p>Nous allons mettre en relation notre base de données avec Hibernate.</p>
            <ol>
                <li>
                    <b>Sélectionnez votre projet</b>
                    dans la liste des projets, et faites un clic-droit dessus, afin de sélectionner
                    <b>File-&gt;New-&gt;Other ...</b>
                </li>
                <li>
                    Choisissez dans la liste
                    <b>Hibernate-&gt;Hibernate Configuration File ...</b>
                </li>
                <li>Une fenêtre s'ouvre, vous demandant quelles sont les coordonnées de la base de données.
					Nous ne traiterons pas ici du côté administratif de la base de données, donc vous êtes libre de créer votre base de données et de donner des droits à l'utilisateur utilisé par Hibernate.
					Concernant l'url de la base de données, la forme est un peu différente en fonction de la base de données, et il n'est malheureusement pas possible de fournir sa construction pour toutes.</li>
                <li>Le fichier de configuration créé, il est conseillé de créer une copie de celui-ci, car un bug dans l'éditeur XML peut l'altérer.</li>
            </ol>
            <p>Note : le plugin n'utilise que des fichiers de configuration XML, donc il n'est pas possible de conserver un fichier hibernate.properties, il faudra le convertir :-(</p>
            <p>Voici pour indication un exemple de fichier hibernate.cfg.xml :</p>
            <textarea name="code" class="xml">
                &lt;?xml version="1.0" encoding="utf-8"?&gt;
                <hibernate-configuration>
                    <session-factory>
                        <!-- local connection properties -->
                        <property name="hibernate.connection.url">jdbc:postgresql://jibe77.org/labo_sun</property>
                        <property name="hibernate.connection.driver_class">org.postgresql.Driver</property>
                        <property name="hibernate.connection.username">java_user</property>
                        <property name="hibernate.connection.password">java is fun</property>
                        <!-- property name="hibernate.connection.pool_size"></property -->
                        <!-- dialect for PostgreSQL -->
                        <property name="dialect">net.sf.hibernate.dialect.PostgreSQLDialect</property>
                        <property name="hibernate.show_sql">false</property>
                        <property name="hibernate.transaction.factory_class">net.sf.hibernate.transaction.JDBCTransactionFactory</property>
                    </session-factory>
                </hibernate-configuration>
            </textarea>
        </div>
        <div class="chapter">
            <h2>12. Ecrire le fichier de mapping</h2>
            <p>
                Comme nous avons vu dans la partie théorique de l'article, le
                <b>fichier de mapping</b>
                fait la relation entre nos
                <b>objets persistants</b>
                et la
                <b>base de données</b>
                .
            </p>
            <p>Voici tout d'abord le schéma UML :</p>
            <center>
                <img src="./images/hibernate_html_m53a74c2f.gif" alt="hibernate_html_m53a74c2f.gif" />
            </center>
            <p>Voici le fichier xml de mapping, commencez par le lire, nous l'expliquerons après :</p>
            <textarea name="code" class="xml">
                &lt;?xml version="1.0"?&gt;
                <hibernate-mapping package="com.supinfo.labosun">
                    <class name="Contact" table="contact">
                        <id name="IdContact" type="integer" column="contact_id">
                            <generator>
                                <param name="sequence" />
                                contact_id_seq
                            </generator>
                        </id>
                        <property name="NameContact" column="contact_name" type="string" not-null="false" length="30" />
                        <property name="BirthContact" column="contact_birth" type="date" not-null="false" length="4" />
                        <set name="Addresses">
                            <key column="contact_id" />
                            <one-to-many />
                        </set>
                    </class>
                    <class name="Address" table="address">
                        <id name="addressId" column="address_id" type="integer">
                            <generator>
                                <param name="sequence" />
                                address_id_seq
                            </generator>
                        </id>
                        <property name="addressCity" column="address_city" type="string" />
                        <property name="addressZipCode" column="address_zipcode" type="integer" length="5" />
                        <many-to-one name="contact" column="contact_id" />
                    </class>
                </hibernate-mapping>
            </textarea>
            <p>
                <b>Deux classes</b>
                sont ici déclarées :
                <b>Contact</b>
                et
                <b>Address</b>
                .
                <br />
                Les balises "
                <b>property</b>
                " déclarent les variables contenues dans chacune des classes. On voit donc que la classe Contact possède les propriétés NameContact et BirthContact. La classe Address possède les propriétés
                <b>addressCity</b>
                et
                <b>addressZipCode</b>
                .
				Les attributs column servent à définir le nom du champs, dans la base de données. On utilise naturellement les types génériques d'Hibernate, qui se chargent de faire la conversion entre les objets dans Java, avec ceux de la base de données.
            </p>
            <p>
                Voyons ensuite les
                <b>identifiants</b>
                des classes. Les identifiants servent à identifier les enregistrements dans la base de donnée, ils sont nécessairents à chaque table (clés primaires en langage relationnel) .
				Celui de la classe Contact est IdContact (contact_id dans la base de données). Une
                <b>séquence</b>
                est nommé contact_id_seq est utilisée afin de le générer.
				De même pour la classe Address, dont l'identifiant est IdAddress (address_id dans la base de données). Une séquence nommée address_id_seq est utilisée afin de la générer.
            </p>
            <p>
                Cependant, si vous n'utilisez pas une base de données qui supporte les séquences, comme MySQL, il est possible d'utiliser
                <b>uuid.hex</b>
                , ou
                <b>increment</b>
                , dans l'attribut
                <i>class</i>
                de la balise "
                <b>generator</b>
                ".
            </p>
            <p>
                Enfin, il nous reste le plus délicat, et le plus intéressant pour la fin. Il s'agit des balises "
                <b>many-to-one</b>
                " et "
                <b>set, map ou list</b>
                " qui vont nous permettre de relier les tables entre elles.
            </p>
            <p>
                Dans notre modèle de données, un objet Contact peut avoir plusieurs références vers l'objet
                <b>Address</b>
                .
            </p>
            <p>
                La balise
                <b>many-to-one</b>
                nous sert à définir une propriété servant de référence à un Contact.
				L'attribut name sert à définir le nom de la propriété (donc l'appel de la méthode getContact() dans l'objet Address retournera le Contact qui est lié), class sert à définir la classe associée, et column, le nom de la colonne.
            </p>
            <p>
                La balise set, dans l'objet Contact est encore plus puissante. Elle nous permet de
                <b>récupérer dans un "java.util.Set"</b>
                l'ensemble des Address où est référencé le Contact.
				L'attribut "
                <i>name</i>
                " est le nom de l'objet Set, "
                <i>key-column</i>
                " est le champ faisant référence au contact, et
                <b>la balise one-to-many sert à définir la classe associée</b>
                .
            </p>
            <p>La relation est ici uni-directionnelle. Il est également possible d'établir des relations bi-directionnelles, mais nous ne verrons pas cela ici. Si vous avez déjà compris le rôle de la base set et one-to-many, il s'agit déjà de bonnes bases :-)</p>
            <p>Il nous reste maintenant à inclure ce mapping dans notre projet.</p>
            <ol>
                <li>Sélectionnez le projet ;</li>
                <li>
                    Faites un clic droit :
                    <b>
                        <i>New -&gt; File -&gt; Other ...</i>
                    </b>
                    ;
                </li>
                <li>
                    Dans la liste, sélectionnez
                    <b>
                        <i>Simple -&gt; File ...</i>
                    </b>
                    puis cliquez sur le bouton "
                    <b>
                        <i>Next</i>
                    </b>
                    "
                    <br />
                    <center>
                        <img src="./images/hibernate_html_11808acd.gif" alt="hibernate_html_11808acd.gif" />
                    </center>
                </li>
                <li>
                    Nommez le fichier "
                    <b>
                        <i>Contact.hbm</i>
                    </b>
                    ", puis cliquez sur
                    <i>Finish</i>
                    ;
                </li>
                <li>
                    Le plugin Hibernate a normalement reconnu le fichier et une icône spécifique à hibernate lui est assigné.
                    <br />
                    <center>
                        <img src="./images/hibernate_html_m5a11319b.gif" alt="hibernate_html_m5a11319b.gif" />
                    </center>
                </li>
                <li>
                    Faites un clic droit sur le fichier de mapping "
                    <b>Contact.hbm</b>
                    ", et sélectionnez
                    <b>Hibernate Synchronizer -&gt; Add Mapping Reference</b>
                    . Si le plugin ne trouve pas le fichier de configuration automatiquement, il vous demandera de la localiser : sélectionnez le fichier hibernate.cfg.xml !
                    <br />
                    <center>
                        <img src="./images/hibernate_html_m777a6ddc.gif" alt="hibernate_html_m777a6ddc.gif" />
                    </center>
                </li>
            </ol>
            <p>
                Cela permet d'ajouter le fichier de mapping dans
                <b>hibernate.cfg.xml</b>
                .
            </p>
        </div>
        <div class="chapter">
            <h2>13. Générer les ordres DDL</h2>
            <p>Une fois notre mapping objet/relationnel écrit, le plus dur est fait, et nous allons le constater.</p>
            <ol>
                <li>
                    Faites un clic-droit sur le fichier de mapping, et sélectionnez
                    <b>Hibernate Synchronize -&gt; Create DDL</b>
                    .
                    <br />
                    <center />
                </li>
                <li>
                    Le plugin vous demandera quelle est la base de données utilisée.
                    <br />
                    <center>
                        <img src="./images/hibernate_html_58b269b5.gif" alt="hibernate_html_58b269b5.gif" />
                    </center>
                </li>
                <li>
                    Il vous demandera aussi un fichier dans lequel il pourra mettre les ordres
                    <b>DDL</b>
                    .
                    <br />
                    <center>
                        <img src="./images/hibernate_html_c2049a2.gif" alt="hibernate_html_c2049a2.gif" />
                    </center>
                </li>
                <li>
                    Nous pouvons voir le résultat :
                    <br />
                    <textarea name="code" class="java">alter table address drop constraint FKBB979BF4856599A
						drop table contact
						drop table address
						drop sequence address_id_seq
						drop sequence contact_id_seq
						create table contact (
						contact_id int4 not null,
						contact_name varchar(30),
						contact_birth date,
						primary key (contact_id)
						)
						create table address (
						address_id int4 not null,
						address_city varchar(255),
						address_zipcode int4,
						contact_id int4,
						primary key (address_id)
						)
						alter table address add constraint FKBB979BF4856599A foreign key (contact_id) references contact
						create sequence address_id_seq
						create sequence contact_id_seq</textarea>
                </li>
            </ol>
            <p>
                Nous voyons dans les premières lignes les ordres de destruction des précédents éléments.
                <br />
                Ensuite, il y a la création des tables, puis de la clé étrangère de la table "address", et enfin, les séquences.
                <br />
                Il ne reste plus qu'à entrer ces commandes dans la base de données.
            </p>
        </div>
        <div class="chapter">
            <h2>14. Générer les classes</h2>
            <p>L'écriture des classes peut, elle aussi, se faire automatiquement.</p>
            <ol>
                <li>
                    Faites un clic droit sur le fichier de mapping, et sélectionnez
                    <b>Hibernate Synchronizer -&gt; Synchronize Files</b>
                    .
                </li>
                <li>
                    Les classes vont être écrites dans le package spécifié dans l'attribut package de la balise
                    <b>
                        <hibernate-mapping />
                    </b>
                    du fichier de mapping.
                </li>
            </ol>
            <p>Nous nous retrouvons avec deux sous-packages, un nommé "base", qui contient l'accès aux données que le plugin possède et peut réécrire lors des changements sur le fichier de mapping.
				L'autre , pour nos objets métiers, qui héritent des précédentes classes. Ces derniers sont dédiés à nos bons désirs :-), on peut en faire ce que l'on veut, ils ne seront pas écrasés par le plugin !</p>
            <center>
                <img src="./images/hibernate_html_5fb206a7.gif" alt="hibernate_html_5fb206a7.gif" />
            </center>
            <p>Maintenant, nous avons mis en place tout ce dont nous aurons besoin... il va maintenant falloir le faire fonctionner !</p>
        </div>
        <div class="chapter">
            <h2>15. Utilisation des classes persistantes</h2>
            <p>Nous allons utiliser les classes que nous avons mises en place. N'oubliez pas d'aller lire et comprendre le fonctionnement des classes générées par le plugin. Ces classes utilisent les objets fondamentaux d'hibernate, c'est pour cela que l'on a pas besoin de le faire soi-même, comme vous allez vous en rendre compte.</p>
            <ol>
                <li>
                    Faites un clic-droit sur le package "
                    <b>com.supinfo.labosun</b>
                    ", et sélectionnez
                    <b>New -&gt; Class ...</b>
                </li>
                <li>
                    Nommez la classe
                    <b>Main</b>
                    , et sélectionnez "
                    <b>public void static main(String[] args)</b>
                    "
                </li>
                <center>
                    <img src="./images/hibernate_html_98f21a5.gif" alt="hibernate_html_98f21a5.gif" />
                </center>
                <li>
                    Hibernate peut lever des exceptions, à travers la classe
                    <b>HibernateException</b>
                    . Il faudra donc faire un "
                    <b>throws HibernateException</b>
                    " sur la fonction main.
                </li>
                Remplacer la ligne par
                <br />
                <textarea name="code" class="java">public static void
					main(String[] args) throws HibernateException {</textarea>
                <li>Il faut ensuite initialiser le SessionFactory.</li>
                <textarea name="code" class="java">_RootDAO.initialize();</textarea>
                <li>Nous allons créer notre premier objet persistant.</li>
                <textarea name="code" class="java">ContactDAO c_dao = new ContactDAO();
					Contact contact = new Contact();
					contact.setNameContact("Phileas Fogg ");
					contact.setBirthContact(new Date());
					c_dao.save(contact);</textarea>
                <p>
                    La création de l'object de type ContactDAO permet de prendre en charger la Session et la transaction avec la base de donnée. C'est une classe créé par le plugin.
					La Contact est telle qu'on l'a spécifié dans le fichier de mapping, et ses propriétés sont manipulables grâce aux "
                    <b>getters</b>
                    " et "
                    <b>setters</b>
                    ".
					L'appel de la méthode
                    <b>save()</b>
                    va donc créer la session, la transaction, et enregistrer l'objet dans la base de données.
                </p>
                <li>Nous allons ensuite définir une adresse à notre contact :-)</li>
                <textarea name="code" class="java">AddressDAO a_dao = new AddressDAO();
					Address address = new Address();
					address.setAddressCity("Paris");
					address.setAddressZipCode(75003);
					address.setContact(contact);
					a_dao.save(address);</textarea>
                <p>C'est le même principe que tout à l'heure. Notez bien que l'on a utilisé l'objet "contact" dans la méthode setContact(Contact) de la classe Address.</p>
                <p>N'hésitez pas à remplir plusieurs adresses, cela mettra en valeur les tests que nous ferons par la suite.</p>
                <li>Nous allons ensuite rechercher ces objets dans la base de données.</li>
                <p>Les commentaires serviront d'explication.</p>
                <textarea name="code" class="java">// on crée l'objet qui nous servira à dialoguer avec la base de données
					// on récupère l'objet session du SessionFactory
					{
					// recherche les contacts qui sont nés après 1995
					Iterator
					contacts = session
					.iterate("from
					Contact c Where c.BirthContact &gt; '01-01-1995'");
					// on affiche les résultats.
					Contact
					c = (Contact) contacts.next();
					System.out.println("un
					contact : " + c.getIdContact() + ":"
					+
					c.getNameContact().trim() + ":"
					+
					c.getBirthContact().toString() + ":");
					// on affiche également les adresses, à travers le Set
					Set
					address_set = c.getAddresses();
					for
					(Object i : address_set) {
					Address
					a = (Address) i;
					System.out.println("l'adresse
					du contact " + a.getAddressId() + ":"
					+
					a.getAddressCity() + ":" + a.getAddressZipCode());
					}
					}</textarea>
                <li>Finalement, pour que le programme fonctionne, hibernate demandera un fichier de configuration pour log4j. Il faut donc créer un fichier nommé " log4j.properties " à la racine du projet, et mettre dedans :</li>
                <textarea name="code" class="java">log4j.appender.stdout=org.apache.log4j.ConsoleAppender
					log4j.appender.stdout.Target=System.out log4j.appender.stdout.layout=org.apache.log4j.PatternLayout
					log4j.appender.stdout.layout.ConversionPattern=%d{ABSOLUTE} %5p %c:%L - %m%n
					log4j.rootLogger=warn, stdout log4j.logger.net.sf.hibernate=info
					log4j.logger.net.sf.hibernate.type=info log4j.logger.net.sf.hibernate.tool.hbm2ddl=debug</textarea>
                <li>Enfin, il arrive quelque fois que l'entête du fichier hibernate.cfg.xml soit effacé par un quelquonque enchantement :-(, ce qui provoque de graves problèmes au démarrage d'hibernate.</li>
                <p>Vérifiez donc que votre fichier de configuration ait bien aux deux premières lignes :</p>
                <textarea name="code" class="xml">&lt;?xml version="1.0" encoding="utf-8"?&gt;</textarea>
                <p>Le programme est prêt à partir. Sélectionner dans le menu Run -&gt; Run ... et créez un profil d'éxécution pour notre application.</p>
                <center>
                    <img src="./images/hibernate_html_3bd54b37.gif" alt="hibernate_html_3bd54b37.gif" />
                </center>
                <p>Finalement, pressez le bouton Run en bas de la fenêtre. La console devrait afficher :</p>
                <center>
                    <img src="./images/hibernate_html_m200be03a.gif" alt="hibernate_html_m200be03a.gif" />
                </center>
            </ol>
            <p>J'espère que ce programme de présentation a marché aussi bien chez vous que chez moi ! ... sinon, n'hésitez pas à nous contacter !</p>
        </div>
        <div class="chapter">
            <h2>16. Les avantages .... et inconvénients</h2>
            <div class="subChapter">
                <h3>16.1. Avantages</h3>
                <ul>
                    <li>
                        Gain de temps si on utilise des outils pour générer automatiquement la base de données et le code. Ce n'est pas la seule possibilité !!!
                        <ul>
                            <li>
                                java vers mapping :
                                <b>xdoclet</b>
                            </li>
                            <li>
                                mapping vers java :
                                <b>xmlSchema</b>
                                (inclus dans hibernate, utilisé par le plugin hibernate-synchronizer)
                            </li>
                            <li>
                                mapping vers ddl :
                                <b>hbm2ddl</b>
                                (inclus dans hibernate, utilisé par le plugin hibernate-synchronizer)
                            </li>
                            <li>
                                ddl vers mapping :
                                <b>middlegen</b>
                            </li>
                        </ul>
                    </li>
                    <li>Les objets métiers sont plus faciles à manipuler.</li>
                    <li>Peu de dépendance envers une base de données précise. Théoriquement, il n'y a que le fichier de configuration à changer si on passe d'une base de données comme Oracle vers PostGreSql.</li>
                </ul>
            </div>
            <div class="subChapter">
                <h3>16.2. Inconvénients</h3>
                <ul>
                    <li>Nécessite d'apprendre à l'utiliser, mais ce n'est pas insurmontable :-)</li>
                </ul>
            </div>
        </div>
        <div class="chapter">
            <h2>17. Conclusion</h2>
            <p>J'espère que cette présentation n'a pas été trop douloureuse :-), et qu' Hibernate aura permis de simplifier l'accès à vos données.</p>
            <p>Nous n'avons, certes, pas tout vu, et pour complément d'information, je vous invite à me contacter sur mon courriel, ou à consulter le site officiel.</p>
            <p>
                Liens :
                <a href="http://www.hibernate.org" target="_blank">www.hibernate.org</a>
            </p>
        </div>
    </body>
</html>

